home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / idlelib / RemoteDebugger.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  14KB  |  404 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. """Support for remote Python debugging.
  5.  
  6. Some ASCII art to describe the structure:
  7.  
  8.        IN PYTHON SUBPROCESS          #             IN IDLE PROCESS
  9.                                      #
  10.                                      #        oid='gui_adapter'
  11.                  +----------+        #       +------------+          +-----+
  12.                  | GUIProxy |--remote#call-->| GUIAdapter |--calls-->| GUI |
  13. +-----+--calls-->+----------+        #       +------------+          +-----+
  14. | Idb |                               #                             /
  15. +-----+<-calls--+------------+         #      +----------+<--calls-/
  16.                 | IdbAdapter |<--remote#call--| IdbProxy |
  17.                 +------------+         #      +----------+
  18.                 oid='idb_adapter'      #
  19.  
  20. The purpose of the Proxy and Adapter classes is to translate certain
  21. arguments and return values that cannot be transported through the RPC
  22. barrier, in particular frame and traceback objects.
  23.  
  24. """
  25. import sys
  26. import types
  27. import rpc
  28. import Debugger
  29. debugging = 0
  30. idb_adap_oid = 'idb_adapter'
  31. gui_adap_oid = 'gui_adapter'
  32. frametable = { }
  33. dicttable = { }
  34. codetable = { }
  35. tracebacktable = { }
  36.  
  37. def wrap_frame(frame):
  38.     fid = id(frame)
  39.     frametable[fid] = frame
  40.     return fid
  41.  
  42.  
  43. def wrap_info(info):
  44.     '''replace info[2], a traceback instance, by its ID'''
  45.     if info is None:
  46.         return None
  47.     else:
  48.         traceback = info[2]
  49.         if not isinstance(traceback, types.TracebackType):
  50.             raise AssertionError
  51.         traceback_id = id(traceback)
  52.         tracebacktable[traceback_id] = traceback
  53.         modified_info = (info[0], info[1], traceback_id)
  54.         return modified_info
  55.  
  56.  
  57. class GUIProxy:
  58.     
  59.     def __init__(self, conn, gui_adap_oid):
  60.         self.conn = conn
  61.         self.oid = gui_adap_oid
  62.  
  63.     
  64.     def interaction(self, message, frame, info = None):
  65.         self.conn.remotecall(self.oid, 'interaction', (message, wrap_frame(frame), wrap_info(info)), { })
  66.  
  67.  
  68.  
  69. class IdbAdapter:
  70.     
  71.     def __init__(self, idb):
  72.         self.idb = idb
  73.  
  74.     
  75.     def set_step(self):
  76.         self.idb.set_step()
  77.  
  78.     
  79.     def set_quit(self):
  80.         self.idb.set_quit()
  81.  
  82.     
  83.     def set_continue(self):
  84.         self.idb.set_continue()
  85.  
  86.     
  87.     def set_next(self, fid):
  88.         frame = frametable[fid]
  89.         self.idb.set_next(frame)
  90.  
  91.     
  92.     def set_return(self, fid):
  93.         frame = frametable[fid]
  94.         self.idb.set_return(frame)
  95.  
  96.     
  97.     def get_stack(self, fid, tbid):
  98.         frame = frametable[fid]
  99.         if tbid is None:
  100.             tb = None
  101.         else:
  102.             tb = tracebacktable[tbid]
  103.         (stack, i) = self.idb.get_stack(frame, tb)
  104.         stack = [ (wrap_frame(frame), k) for frame, k in stack ]
  105.         return (stack, i)
  106.  
  107.     
  108.     def run(self, cmd):
  109.         import __main__ as __main__
  110.         self.idb.run(cmd, __main__.__dict__)
  111.  
  112.     
  113.     def set_break(self, filename, lineno):
  114.         msg = self.idb.set_break(filename, lineno)
  115.         return msg
  116.  
  117.     
  118.     def clear_break(self, filename, lineno):
  119.         msg = self.idb.clear_break(filename, lineno)
  120.         return msg
  121.  
  122.     
  123.     def clear_all_file_breaks(self, filename):
  124.         msg = self.idb.clear_all_file_breaks(filename)
  125.         return msg
  126.  
  127.     
  128.     def frame_attr(self, fid, name):
  129.         frame = frametable[fid]
  130.         return getattr(frame, name)
  131.  
  132.     
  133.     def frame_globals(self, fid):
  134.         frame = frametable[fid]
  135.         dict = frame.f_globals
  136.         did = id(dict)
  137.         dicttable[did] = dict
  138.         return did
  139.  
  140.     
  141.     def frame_locals(self, fid):
  142.         frame = frametable[fid]
  143.         dict = frame.f_locals
  144.         did = id(dict)
  145.         dicttable[did] = dict
  146.         return did
  147.  
  148.     
  149.     def frame_code(self, fid):
  150.         frame = frametable[fid]
  151.         code = frame.f_code
  152.         cid = id(code)
  153.         codetable[cid] = code
  154.         return cid
  155.  
  156.     
  157.     def code_name(self, cid):
  158.         code = codetable[cid]
  159.         return code.co_name
  160.  
  161.     
  162.     def code_filename(self, cid):
  163.         code = codetable[cid]
  164.         return code.co_filename
  165.  
  166.     
  167.     def dict_keys(self, did):
  168.         dict = dicttable[did]
  169.         return dict.keys()
  170.  
  171.     
  172.     def dict_item(self, did, key):
  173.         dict = dicttable[did]
  174.         value = dict[key]
  175.         value = repr(value)
  176.         return value
  177.  
  178.  
  179.  
  180. def start_debugger(rpchandler, gui_adap_oid):
  181.     '''Start the debugger and its RPC link in the Python subprocess
  182.  
  183.     Start the subprocess side of the split debugger and set up that side of the
  184.     RPC link by instantiating the GUIProxy, Idb debugger, and IdbAdapter
  185.     objects and linking them together.  Register the IdbAdapter with the
  186.     RPCServer to handle RPC requests from the split debugger GUI via the
  187.     IdbProxy.
  188.  
  189.     '''
  190.     gui_proxy = GUIProxy(rpchandler, gui_adap_oid)
  191.     idb = Debugger.Idb(gui_proxy)
  192.     idb_adap = IdbAdapter(idb)
  193.     rpchandler.register(idb_adap_oid, idb_adap)
  194.     return idb_adap_oid
  195.  
  196.  
  197. class FrameProxy:
  198.     
  199.     def __init__(self, conn, fid):
  200.         self._conn = conn
  201.         self._fid = fid
  202.         self._oid = 'idb_adapter'
  203.         self._dictcache = { }
  204.  
  205.     
  206.     def __getattr__(self, name):
  207.         if name[:1] == '_':
  208.             raise AttributeError, name
  209.         
  210.         if name == 'f_code':
  211.             return self._get_f_code()
  212.         
  213.         if name == 'f_globals':
  214.             return self._get_f_globals()
  215.         
  216.         if name == 'f_locals':
  217.             return self._get_f_locals()
  218.         
  219.         return self._conn.remotecall(self._oid, 'frame_attr', (self._fid, name), { })
  220.  
  221.     
  222.     def _get_f_code(self):
  223.         cid = self._conn.remotecall(self._oid, 'frame_code', (self._fid,), { })
  224.         return CodeProxy(self._conn, self._oid, cid)
  225.  
  226.     
  227.     def _get_f_globals(self):
  228.         did = self._conn.remotecall(self._oid, 'frame_globals', (self._fid,), { })
  229.         return self._get_dict_proxy(did)
  230.  
  231.     
  232.     def _get_f_locals(self):
  233.         did = self._conn.remotecall(self._oid, 'frame_locals', (self._fid,), { })
  234.         return self._get_dict_proxy(did)
  235.  
  236.     
  237.     def _get_dict_proxy(self, did):
  238.         if self._dictcache.has_key(did):
  239.             return self._dictcache[did]
  240.         
  241.         dp = DictProxy(self._conn, self._oid, did)
  242.         self._dictcache[did] = dp
  243.         return dp
  244.  
  245.  
  246.  
  247. class CodeProxy:
  248.     
  249.     def __init__(self, conn, oid, cid):
  250.         self._conn = conn
  251.         self._oid = oid
  252.         self._cid = cid
  253.  
  254.     
  255.     def __getattr__(self, name):
  256.         if name == 'co_name':
  257.             return self._conn.remotecall(self._oid, 'code_name', (self._cid,), { })
  258.         
  259.         if name == 'co_filename':
  260.             return self._conn.remotecall(self._oid, 'code_filename', (self._cid,), { })
  261.         
  262.  
  263.  
  264.  
  265. class DictProxy:
  266.     
  267.     def __init__(self, conn, oid, did):
  268.         self._conn = conn
  269.         self._oid = oid
  270.         self._did = did
  271.  
  272.     
  273.     def keys(self):
  274.         return self._conn.remotecall(self._oid, 'dict_keys', (self._did,), { })
  275.  
  276.     
  277.     def __getitem__(self, key):
  278.         return self._conn.remotecall(self._oid, 'dict_item', (self._did, key), { })
  279.  
  280.     
  281.     def __getattr__(self, name):
  282.         raise AttributeError, name
  283.  
  284.  
  285.  
  286. class GUIAdapter:
  287.     
  288.     def __init__(self, conn, gui):
  289.         self.conn = conn
  290.         self.gui = gui
  291.  
  292.     
  293.     def interaction(self, message, fid, modified_info):
  294.         frame = FrameProxy(self.conn, fid)
  295.         self.gui.interaction(message, frame, modified_info)
  296.  
  297.  
  298.  
  299. class IdbProxy:
  300.     
  301.     def __init__(self, conn, shell, oid):
  302.         self.oid = oid
  303.         self.conn = conn
  304.         self.shell = shell
  305.  
  306.     
  307.     def call(self, methodname, *args, **kwargs):
  308.         value = self.conn.remotecall(self.oid, methodname, args, kwargs)
  309.         return value
  310.  
  311.     
  312.     def run(self, cmd, locals):
  313.         seq = self.conn.asyncqueue(self.oid, 'run', (cmd,), { })
  314.         self.shell.interp.active_seq = seq
  315.  
  316.     
  317.     def get_stack(self, frame, tbid):
  318.         (stack, i) = self.call('get_stack', frame._fid, tbid)
  319.         stack = [ (FrameProxy(self.conn, fid), k) for fid, k in stack ]
  320.         return (stack, i)
  321.  
  322.     
  323.     def set_continue(self):
  324.         self.call('set_continue')
  325.  
  326.     
  327.     def set_step(self):
  328.         self.call('set_step')
  329.  
  330.     
  331.     def set_next(self, frame):
  332.         self.call('set_next', frame._fid)
  333.  
  334.     
  335.     def set_return(self, frame):
  336.         self.call('set_return', frame._fid)
  337.  
  338.     
  339.     def set_quit(self):
  340.         self.call('set_quit')
  341.  
  342.     
  343.     def set_break(self, filename, lineno):
  344.         msg = self.call('set_break', filename, lineno)
  345.         return msg
  346.  
  347.     
  348.     def clear_break(self, filename, lineno):
  349.         msg = self.call('clear_break', filename, lineno)
  350.         return msg
  351.  
  352.     
  353.     def clear_all_file_breaks(self, filename):
  354.         msg = self.call('clear_all_file_breaks', filename)
  355.         return msg
  356.  
  357.  
  358.  
  359. def start_remote_debugger(rpcclt, pyshell):
  360.     '''Start the subprocess debugger, initialize the debugger GUI and RPC link
  361.  
  362.     Request the RPCServer start the Python subprocess debugger and link.  Set
  363.     up the Idle side of the split debugger by instantiating the IdbProxy,
  364.     debugger GUI, and debugger GUIAdapter objects and linking them together.
  365.  
  366.     Register the GUIAdapter with the RPCClient to handle debugger GUI
  367.     interaction requests coming from the subprocess debugger via the GUIProxy.
  368.  
  369.     The IdbAdapter will pass execution and environment requests coming from the
  370.     Idle debugger GUI to the subprocess debugger via the IdbProxy.
  371.  
  372.     '''
  373.     global idb_adap_oid
  374.     idb_adap_oid = rpcclt.remotecall('exec', 'start_the_debugger', (gui_adap_oid,), { })
  375.     idb_proxy = IdbProxy(rpcclt, pyshell, idb_adap_oid)
  376.     gui = Debugger.Debugger(pyshell, idb_proxy)
  377.     gui_adap = GUIAdapter(rpcclt, gui)
  378.     rpcclt.register(gui_adap_oid, gui_adap)
  379.     return gui
  380.  
  381.  
  382. def close_remote_debugger(rpcclt):
  383.     '''Shut down subprocess debugger and Idle side of debugger RPC link
  384.  
  385.     Request that the RPCServer shut down the subprocess debugger and link.
  386.     Unregister the GUIAdapter, which will cause a GC on the Idle process
  387.     debugger and RPC link objects.  (The second reference to the debugger GUI
  388.     is deleted in PyShell.close_remote_debugger().)
  389.  
  390.     '''
  391.     close_subprocess_debugger(rpcclt)
  392.     rpcclt.unregister(gui_adap_oid)
  393.  
  394.  
  395. def close_subprocess_debugger(rpcclt):
  396.     rpcclt.remotecall('exec', 'stop_the_debugger', (idb_adap_oid,), { })
  397.  
  398.  
  399. def restart_subprocess_debugger(rpcclt):
  400.     idb_adap_oid_ret = rpcclt.remotecall('exec', 'start_the_debugger', (gui_adap_oid,), { })
  401.     if not idb_adap_oid_ret == idb_adap_oid:
  402.         raise AssertionError, 'Idb restarted with different oid'
  403.  
  404.